
# this will help in making the Python code more structured automatically (good coding practice)
%load_ext nb_black

# Libraries to help with reading and manipulating data
import numpy as np
import pandas as pd

# Libraries to help with data visualization
import matplotlib.pyplot as plt
import seaborn as sns

sns.set()

# split the data into train and test
from sklearn.model_selection import train_test_split

# to build linear regression_model
from sklearn.linear_model import LinearRegression

# to check model performance
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

# to build linear regression_model using statsmodels
import statsmodels.api as sm

# to compute VIF
from statsmodels.stats.outliers_influence import variance_inflation_factor


Rcel = pd.read_csv("/Users/Moses Okesola/Downloads/used_device_data.csv")
Rcel.head()


Rcel.T


Rcel.shape

(3454, 15)


Rcel.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 3454 entries, 0 to 3453
Data columns (total 15 columns):
 #   Column                 Non-Null Count  Dtype  
---  ------                 --------------  -----  
 0   brand_name             3454 non-null   object 
 1   os                     3454 non-null   object 
 2   screen_size            3454 non-null   float64
 3   4g                     3454 non-null   object 
 4   5g                     3454 non-null   object 
 5   main_camera_mp         3275 non-null   float64
 6   selfie_camera_mp       3452 non-null   float64
 7   int_memory             3450 non-null   float64
 8   ram                    3450 non-null   float64
 9   battery                3448 non-null   float64
 10  weight                 3447 non-null   float64
 11  release_year           3454 non-null   int64  
 12  days_used              3454 non-null   int64  
 13  normalized_used_price  3454 non-null   float64
 14  normalized_new_price   3454 non-null   float64
dtypes: float64(9), int64(2), object(4)
memory usage: 404.9+ KB


Rcel.columns

Index(['brand_name', 'os', 'screen_size', '4g', '5g', 'main_camera_mp',
       'selfie_camera_mp', 'int_memory', 'ram', 'battery', 'weight',
       'release_year', 'days_used', 'normalized_used_price',
       'normalized_new_price'],
      dtype='object')


Rcel.describe(include="all").T


Rcel.duplicated().sum()

0


Rcel.isnull().sum()

brand_name                 0
os                         0
screen_size                0
4g                         0
5g                         0
main_camera_mp           179
selfie_camera_mp           2
int_memory                 4
ram                        4
battery                    6
weight                     7
release_year               0
days_used                  0
normalized_used_price      0
normalized_new_price       0
dtype: int64


df = Rcel.copy()


# Get the list of all numerical variables, including 'normalized_used_price'
numerical_vars_all = Rcel.select_dtypes(include=['float64', 'int64']).columns.tolist()

# Print the list of all numerical variables
print("All Numerical Variables:")
for var in numerical_vars_all:
    print(var)

All Numerical Variables:
screen_size
main_camera_mp
selfie_camera_mp
int_memory
ram
battery
weight
release_year
days_used
normalized_used_price
normalized_new_price


# Extract features excluding the dependent variable 'normalized_used_price'
feature = Rcel.drop(columns=["normalized_used_price"])

# Check the extracted features
(feature.head()).T


# Histogram-boxplot combined plots for numerical variables
def histogram_boxplot(Rcel, feature, figsize=(15, 10), kde=False, bins=None):
    """
    Boxplot and histogram combined

    Rcel: dataframe
    feature: dataframe column
    figsize: size of figure (default (15,10))
    kde: whether to show the density curve (default False)
    bins: number of bins for histogram (default None)
    """
    f2, (ax_box2, ax_hist2) = plt.subplots(
        nrows=2,
        sharex=True,
        gridspec_kw={"height_ratios": (0.25, 0.75)},
        figsize=figsize,
    )
    sns.boxplot(data=Rcel, x=feature, ax=ax_box2, showmeans=True, color="violet")
    
    if bins:
        sns.histplot(data=Rcel, x=feature, kde=kde, ax=ax_hist2, bins=bins)
    else:
        sns.histplot(data=Rcel, x=feature, kde=kde, ax=ax_hist2)
    
    ax_hist2.axvline(Rcel[feature].mean(), color="green", linestyle="--")  # Add mean to the histogram
    ax_hist2.axvline(Rcel[feature].median(), color="black", linestyle="-")  # Add median to the histogram


# function to create labeled barplots


def labeled_barplot(data, feature, perc=False, n=None):
    """
    Barplot with percentage at the top

    data: dataframe
    feature: dataframe column
    perc: whether to display percentages instead of count (default is False)
    n: displays the top n category levels (default is None, i.e., display all levels)
    """

    total = len(data[feature])  # length of the column
    count = data[feature].nunique()
    if n is None:
        plt.figure(figsize=(count + 2, 6))
    else:
        plt.figure(figsize=(n + 2, 6))

    plt.xticks(rotation=90, fontsize=15)
    ax = sns.countplot(
        data=data,
        x=feature,
        palette="Paired",
        order=data[feature].value_counts().index[:n],
    )

    for p in ax.patches:
        if perc == True:
            label = "{:.1f}%".format(
                100 * p.get_height() / total
            )  # percentage of each class of the category
        else:
            label = p.get_height()  # count of each level of the category

        x = p.get_x() + p.get_width() / 2  # width of the plot
        y = p.get_height()  # height of the plot

        ax.annotate(
            label,
            (x, y),
            ha="center",
            va="center",
            size=12,
            xytext=(0, 5),
            textcoords="offset points",
        )  # annotate the percentage

    plt.show()  # show the plot


# the column that contains information about the normalized used prices
normalized_used_price_class = df["normalized_used_price"].unique()
normalized_used_price_class

array([4.30757245, 5.16209665, 5.11108377, ..., 5.03773152, 4.35734965,
       4.34976167])


# plotting the distribution of normalized used device prices

plt.figure(figsize=(14, 7))

# Subplot 1: Histogram of normalized used device prices with count labels
plt.subplot(1, 2, 1)
ax1 = sns.histplot(df["normalized_used_price"], bins=20, color="skyblue", edgecolor="black")
plt.title("Distribution of Normalized Used Device Prices")
plt.xlabel("Normalized Used Price")
plt.ylabel("Frequency")

# Add count labels to the histogram
for rect in ax1.patches:
    height = rect.get_height()
    ax1.text(rect.get_x() + rect.get_width() / 2, height, height, ha='center', va='bottom')

# Subplot 2: Boxplot of normalized used device prices
plt.subplot(1, 2, 2)
ax2 = sns.boxplot(y="normalized_used_price", data=df, color="lightblue")
plt.title("Boxplot of Normalized Used Device Prices")

plt.tight_layout()
plt.show()


# the column that contains information about the operating systems
os_types = df["os"].unique()
os_types

array(['Android', 'Others', 'iOS', 'Windows'], dtype=object)


# Plot the labeled barplot for the OS on which the device runs
labeled_barplot(df, "os", perc=True, n=10)


# Calculate the percentage of the used device market dominated by Android devices
total_devices = len(df)
android_devices = len(df[df["os"] == "Android"])
android_market_share = (android_devices / total_devices) * 100

# Create a vertical bar plot to visualize the market share
plt.figure(figsize=(8, 6))
plt.bar(
    ["Android Devices", "Other Devices"],
    [android_market_share, 100 - android_market_share],
    color=["skyblue", "lightcoral"],
)
plt.ylabel("Percentage (%)")
plt.title("Percentage of Used Device Market Dominated by Android Devices")
plt.ylim(0, 100)  # Set y-axis limits from 0 to 100 for percentage scale

# Display the percentage values on the bars
for index, value in enumerate([android_market_share, 100 - android_market_share]):
    plt.text(index, value, f"{value:.2f}%", ha="center", va="bottom")

plt.show()


# the column that contains information about the RAM
ram_sizes = df["ram"].unique()
ram_sizes

array([ 3.  ,  8.  ,  6.  ,  4.  ,  2.  ,  1.  , 12.  ,  0.5 ,  0.25,
        0.03,   nan,  0.02,  1.5 ])


# Plot the histogram and boxplot for amount of RAM
histogram_boxplot(df, "ram")


# Plot the histogram and boxplot for the screen size
histogram_boxplot(df, "screen_size")


# the column that contains information about the normalized new prices
normalized_new_price_class = df["normalized_new_price"].unique()
normalized_new_price_class

array([4.71510025, 5.51901794, 5.88463072, ..., 6.25153773, 4.62418819,
       4.27999391])


# plot the histogram-boxplot for Normalized price of a new device of the same model
histogram_boxplot(df, "normalized_new_price")


# the column that contains information about the resolution of the rear camera
main_camera_mp_types = df["main_camera_mp"].unique()
main_camera_mp_types

array([13.  ,  8.  ,  5.  , 10.5 ,  3.15,   nan,  2.  , 16.  ,  0.3 ,
       12.  , 14.5 , 48.  ,  3.  , 21.  ,  1.3 , 13.1 , 24.  ,  0.08,
       20.7 , 23.  ,  1.  , 18.  , 12.2 , 12.3 , 20.  , 20.2 ,  4.  ,
       12.5 , 10.  ,  6.5 ,  6.7 , 41.  , 20.1 , 12.6 , 16.3 , 22.6 ,
       19.  , 21.5 , 21.2 ,  8.1 ,  1.2 , 22.5 ])


# Plot the histogram and boxplot for the resolution of the rear camera
histogram_boxplot(df, "main_camera_mp")


# the column that contains information about the resolution of the frontcamera
selfie_camera_mp_types = df["selfie_camera_mp"].unique()
selfie_camera_mp_types

array([ 5.  , 16.  ,  8.  , 32.  ,  2.  ,  0.3 , 13.  , 14.5 , 24.  ,
       10.  ,  1.3 , 20.  , 25.  ,  0.  , 12.  ,  7.  ,  1.2 ,  3.  ,
        2.1 ,  1.  ,  4.  ,  1.1 ,   nan, 10.5 ,  1.6 ,  1.8 ,  3.5 ,
        0.9 ,  1.25, 18.  ,  1.9 ,  9.  ,  3.7 , 16.3 ,  5.1 ,  2.2 ,
       14.  ,  0.65])


# Plot the histogram and boxplot for the resolution of the front camera
histogram_boxplot(df, "selfie_camera_mp")


# the column that contains information about the internal memory
int_memory_sizes = df["int_memory"].unique()
int_memory_sizes

array([6.400e+01, 1.280e+02, 3.200e+01, 1.600e+01, 2.560e+02, 5.120e+02,
       8.000e+00, 4.000e+00, 5.000e-01, 2.000e-01, 1.000e-01, 6.000e-02,
             nan, 1.024e+03, 2.400e+01, 1.000e-02])


# Plot the histogram and boxplot for the internal memory of the device
histogram_boxplot(df, "int_memory")


# Plot the histogram and boxplot for the weight of the device
histogram_boxplot(df, "weight")


# Plot the histogram and boxplot for the Energy capacity of the device battery
histogram_boxplot(df, "battery")


# Plot the histogram and boxplot for the number of days the used/refurbished device has been used
histogram_boxplot(df, "days_used")


# Plot the labeled barplot for the name of manufacturing brand
labeled_barplot(df, "brand_name", perc=True, n=10)


# Plot the labeled barplot for the name of manufacturing brand
labeled_barplot(df, "4g", perc=True, n=10)


# Plot the labeled barplot for the name of manufacturing brand
labeled_barplot(df, "5g", perc=True, n=10)


# Plot the labeled barplot for the operating system of the devices
labeled_barplot(df, "os", perc=True, n=10)


# Plot the labeled barplot for the year when the device model was released
labeled_barplot(df, "release_year", perc=True, n=10)


cols_list = df.select_dtypes(include=np.number).columns.tolist()
# dropping release_year as it is a temporal variable
cols_list.remove("release_year")

plt.figure(figsize=(15, 7))
sns.heatmap(
    df[cols_list].corr(), annot=True, vmin=-1, vmax=1, fmt=".2f", cmap="Spectral"
)
plt.show()


# Get the list of all numerical variables, excluding 'normalized_used_price' and 'release_year'
numerical_vars_all = df.select_dtypes(include=["float64", "int64"]).columns.tolist()
numerical_vars = [var for var in numerical_vars_all if var not in ["normalized_used_price", "release_year"]]

# Creating scatter plots for each numerical feature against the normalized used price
for feature in numerical_vars:
    plt.figure(figsize=(10, 6))
    sns.scatterplot(data=df, x=feature, y="normalized_used_price")
    plt.title(f"Scatter plot of {feature} vs. Normalized Used Price")
    plt.xlabel(feature)
    plt.ylabel("Normalized Used Price")
    plt.show()


# Create a box plot of the normalized used price versus categorical variables
cat_vars = df.select_dtypes(include=["object", "category"]).columns.tolist()
for feature in cat_vars:
    plt.figure(figsize=(18, 8))  # Set the figure size for each plot
    sns.boxplot(x=feature, y="normalized_used_price", data=df, width=0.8)
    plt.title(f"Box Plot of Normalized Used Price by {feature}")
    plt.xlabel(feature)
    plt.ylabel("Normalized Used Price")
    plt.xticks(rotation=90)
    plt.show()  # Display the plot in each iteration of the loop


# Variation of RAM with the brand

plt.figure(figsize=(12, 6))
sns.boxplot(x="brand_name", y="ram", data=df)
plt.title("Variation of RAM with Brand")
plt.xlabel("Brand Name")
plt.ylabel("RAM (GB)")
plt.xticks(rotation=90)
plt.show()


# dataset for devices with large battery>4500 mAh
df_large_battery = df[df.battery > 4500]
df_large_battery.shape

(341, 15)


# Filter devices with large batteries (> 4500 mAh)
df_large_battery = df[df["battery"] > 4500]

# Create a box plot for 'brand_name' and 'weight' in the df_large_battery dataframe
plt.figure(figsize=(15, 5))
sns.boxplot(x="brand_name", y="weight", data=df_large_battery)
plt.xticks(rotation=90)
plt.title("Box Plot of Weight by Brand Name for Devices with Large Batteries")
plt.xlabel("Brand Name")
plt.ylabel("Weight (grams)")
plt.show()


# Convert screen size from inches to cm (1 inch =2.54 cm)
df_large_screen = df[df.screen_size > 6 * 2.54]
df_large_screen.shape

(1099, 15)


# Call the labeled_barplot function to analyze the data
df_large_screen = df[
    df.screen_size > 6 * 2.54
]  ## Convert screen size from inches to cm (1 inch =2.54 cm)

labeled_barplot(data=df_large_screen, feature="brand_name", perc=True, n=10)


# Filter the original DataFrame for devices with selfie camera resolution greater than 8 megapixels
df_selfie_camera = df[df.selfie_camera_mp > 8]
df_selfie_camera.shape

(655, 15)


# Call the labeled_barplot function to analyze the data
labeled_barplot(data=df_selfie_camera, feature="brand_name", perc=True, n=10)


df_main_camera = df[df.main_camera_mp > 16]
df_main_camera.shape

(94, 15)


# Call the labeled_barplot function to analyze the data
labeled_barplot(data=df_main_camera, feature="brand_name", perc=True, n=10)


# create lineplot of normalized_used_price and release_year
plt.figure(figsize=(12, 5))
sns.lineplot(x="release_year", y="normalized_used_price", data=df)
plt.show()


# create a copy of the dataset to keep the original dataset unchanged
df1 = df.copy()


# checking for missing values
df1.isnull().sum()

brand_name                 0
os                         0
screen_size                0
4g                         0
5g                         0
main_camera_mp           179
selfie_camera_mp           2
int_memory                 4
ram                        4
battery                    6
weight                     7
release_year               0
days_used                  0
normalized_used_price      0
normalized_new_price       0
dtype: int64


# List columns with missing values in the DataFrame df1
columns_with_missing_values = df.columns[df.isnull().any()].tolist()

# Displaying the column names with missing values
for col in columns_with_missing_values:
    print(col)

main_camera_mp
selfie_camera_mp
int_memory
ram
battery
weight


# Impute missing values in cols_impute with median by grouping the data on 'release_year' and 'brand_name'
for col in columns_with_missing_values:
    df1[col] = df1[col].fillna(
        value=df1.groupby(["release_year", "brand_name"])[col].transform("median")
    )

# Check for missing values after imputing the above columns
missing_values_count = df1.isnull().sum()
print(missing_values_count)

brand_name                 0
os                         0
screen_size                0
4g                         0
5g                         0
main_camera_mp           179
selfie_camera_mp           2
int_memory                 0
ram                        0
battery                    6
weight                     7
release_year               0
days_used                  0
normalized_used_price      0
normalized_new_price       0
dtype: int64


# Impute missing values in cols_impute with median by grouping the data on 'brand_name'
for col in columns_with_missing_values:
    df1[col] = df1[col].fillna(
        value=df1.groupby(['brand_name'])[col].transform("median")
    )

# Check for missing values after imputing the above columns
missing_values_count = df1.isnull().sum()
print(missing_values_count)

brand_name                0
os                        0
screen_size               0
4g                        0
5g                        0
main_camera_mp           10
selfie_camera_mp          0
int_memory                0
ram                       0
battery                   0
weight                    0
release_year              0
days_used                 0
normalized_used_price     0
normalized_new_price      0
dtype: int64


# Impute missing values in 'main_camera_mp' column with median
median_main_camera_mp = df1["main_camera_mp"].median()
df1["main_camera_mp"] = df1["main_camera_mp"].fillna(median_main_camera_mp)

# Check for missing values after imputing the "main_camera_mp" column
missing_values_count = df1.isnull().sum()
print(missing_values_count)

brand_name               0
os                       0
screen_size              0
4g                       0
5g                       0
main_camera_mp           0
selfie_camera_mp         0
int_memory               0
ram                      0
battery                  0
weight                   0
release_year             0
days_used                0
normalized_used_price    0
normalized_new_price     0
dtype: int64


# One-hot encoding for 'os' column
df1_encoded = pd.get_dummies(df1, columns=['os'], prefix='os')

# One-hot encoding for 'os' and 'brand_name' columns
df1_encoded = pd.get_dummies(df1, columns=['os', 'brand_name'], prefix=['os', 'brand_name'])



from sklearn.preprocessing import LabelEncoder

# Check if the columns '4g' and '5g' exist in the DataFrame
if "4g" in df1.columns and "5g" in df1.columns:
    # Initialize LabelEncoder
    label_encoder = LabelEncoder()

    # Encode '4g' and '5g' columns with 'yes' as 1 and 'no' as 0
    df1["4g_encoded"] = label_encoder.fit_transform(df1["4g"])
    df1["5g_encoded"] = label_encoder.fit_transform(df1["5g"])
else:
    print("Columns '4g' and/or '5g' not found in the DataFrame.")


# Calculate age of the device based on release year
current_year = 2021
df1["age_of_device"] = current_year - df1["release_year"]
df1.drop("release_year", axis=1, inplace=True)
df1["age_of_device"].describe()

count    3454.000000
mean        5.034742
std         2.298455
min         1.000000
25%         3.000000
50%         5.500000
75%         7.000000
max         8.000000
Name: age_of_device, dtype: float64


# outlier detection using boxplot
num_cols = df1.select_dtypes(include=np.number).columns.tolist()

plt.figure(figsize=(15, 15))

for i, variable in enumerate(num_cols):
    if i < 12:  # Limit the subplots to 12
        plt.subplot(3, 4, i + 1)
        sns.boxplot(data=df1, x=variable)

plt.subplots_adjust(wspace=0.5, hspace=0.5)  # Adjust the space between subplots

plt.show()


# Calculate the median for updated numerical variables
median = df1[numerical_vars].median()

# Create a copy of the original DataFrame
df1_outliers_corrected = df1.copy()

# Determine outliers using a condition based on median value and standard deviation (adjust as needed)
lower_bound = median - 3 * df1[numerical_vars].std()
upper_bound = median + 3 * df1[numerical_vars].std()
outliers = (df1[numerical_vars] < lower_bound) | (df1[numerical_vars] > upper_bound)


# separating independent variables from dependent variables
X = df1.drop(columns=["normalized_used_price"]) # independent variables
# target_variable for prediction
y = df1['normalized_used_price']

print(X.head())
print()
print(y.head())

  brand_name       os  screen_size   4g   5g  main_camera_mp  \
0      Honor  Android        14.50  yes   no            13.0   
1      Honor  Android        17.30  yes  yes            13.0   
2      Honor  Android        16.69  yes  yes            13.0   
3      Honor  Android        25.50  yes  yes            13.0   
4      Honor  Android        15.32  yes   no            13.0   

   selfie_camera_mp  int_memory  ram  battery  weight  days_used  \
0               5.0        64.0  3.0   3020.0   146.0        127   
1              16.0       128.0  8.0   4300.0   213.0        325   
2               8.0       128.0  8.0   4200.0   213.0        162   
3               8.0        64.0  6.0   7250.0   480.0        345   
4               8.0        64.0  3.0   5000.0   185.0        293   

   normalized_new_price  4g_encoded  5g_encoded  age_of_device  
0              4.715100           1           0              1  
1              5.519018           1           1              1  
2              5.884631           1           1              1  
3              5.630961           1           1              1  
4              4.947837           1           0              1  

0    4.307572
1    5.162097
2    5.111084
3    5.135387
4    4.389995
Name: normalized_used_price, dtype: float64


# let's add the intercept to data
X = sm.add_constant(X)


# creating dummy variables
X = pd.get_dummies(
    X,
    columns=X.select_dtypes(include=["object", "category"]).columns.tolist(),
    drop_first=True,
)  ## create dummies for independent features

X.head()


# Perform the train-test split with a 70:30 ratio
x_train, x_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)
# Code is assuming 'X' contains the independent variables and 'y' is the dependent variable
# 'test_size=0.3' specifies a 70:30 split for the training and testing data
# 'random_state=42' ensures reproducibility of the split

# Print the shapes of the resulting datasets
print("Shape of x_train:", x_train.shape[0])
print("Shape of x_test:", x_test.shape[0])
print("Shape of y_train:", y_train.shape[0])
print("Shape of y_test:", y_test.shape[0])

Shape of x_train: 2417
Shape of x_test: 1037
Shape of y_train: 2417
Shape of y_test: 1037


df1.describe(include="all").T


df1.isnull().sum()

brand_name               0
os                       0
screen_size              0
4g                       0
5g                       0
main_camera_mp           0
selfie_camera_mp         0
int_memory               0
ram                      0
battery                  0
weight                   0
days_used                0
normalized_used_price    0
normalized_new_price     0
4g_encoded               0
5g_encoded               0
age_of_device            0
dtype: int64


histogram_boxplot(df, "normalized_used_price")


histogram_boxplot(df, "normalized_new_price")


histogram_boxplot(df, "screen_size")


histogram_boxplot(df, "main_camera_mp")


histogram_boxplot(df, "selfie_camera_mp")


histogram_boxplot(df, "int_memory")


histogram_boxplot(df, "ram")


histogram_boxplot(df, "weight")


histogram_boxplot(df, "battery")


histogram_boxplot(df, "days_used")


labeled_barplot(df, "brand_name", perc=True, n=10)


labeled_barplot(df, "os", perc=True, n=10)


labeled_barplot(df, "4g", perc=True, n=10)


labeled_barplot(df, "5g", perc=True, n=10)


labeled_barplot(df, "release_year", perc=True, n=10)


cols_list = df.select_dtypes(include=np.number).columns.tolist()
plt.figure(figsize=(15, 7))
sns.heatmap(
    df[cols_list].corr(), annot=True, vmin=-1, vmax=1, fmt=".2f", cmap="Spectral"
)
plt.show()


# Convert pandas DataFrames to numpy arrays for endogenous and exogenous variables
y_train_arr = y_train.values.astype(float)  # Convert to float type
x_train_arr = x_train.values.astype(float)  # Convert to float type

# Fit the OLS model using numpy arrays
olsmodel1 = sm.OLS(y_train_arr, x_train_arr)
ols_result = olsmodel1.fit()

# Print the summary of the OLS model
print(ols_result.summary())

                            OLS Regression Results                            
==============================================================================
Dep. Variable:                      y   R-squared:                       0.849
Model:                            OLS   Adj. R-squared:                  0.846
Method:                 Least Squares   F-statistic:                     277.1
Date:                Fri, 22 Mar 2024   Prob (F-statistic):               0.00
Time:                        15:34:46   Log-Likelihood:                 125.15
No. Observations:                2417   AIC:                            -152.3
Df Residuals:                    2368   BIC:                             131.4
Df Model:                          48                                         
Covariance Type:            nonrobust                                         
==============================================================================
                 coef    std err          t      P>|t|      [0.025      0.975]
------------------------------------------------------------------------------
const          1.4172      0.072     19.677      0.000       1.276       1.558
x1             0.0295      0.004      8.352      0.000       0.023       0.036
x2             0.0232      0.002     14.892      0.000       0.020       0.026
x3             0.0116      0.001      9.924      0.000       0.009       0.014
x4             0.0002   6.76e-05      2.779      0.005    5.53e-05       0.000
x5             0.0305      0.005      5.797      0.000       0.020       0.041
x6         -1.665e-05   7.35e-06     -2.266      0.024   -3.11e-05   -2.24e-06
x7             0.0008      0.000      5.946      0.000       0.001       0.001
x8          3.376e-05   3.07e-05      1.101      0.271   -2.64e-05    9.39e-05
x9             0.4104      0.012     33.494      0.000       0.386       0.434
x10            0.0203      0.008      2.514      0.012       0.004       0.036
x11           -0.0458      0.016     -2.846      0.004      -0.077      -0.014
x12           -0.0255      0.005     -5.589      0.000      -0.034      -0.017
x13           -0.0804      0.050     -1.618      0.106      -0.178       0.017
x14           -0.0438      0.148     -0.297      0.767      -0.333       0.246
x15            0.0068      0.049      0.138      0.890      -0.090       0.103
x16            0.0312      0.072      0.434      0.664      -0.110       0.172
x17           -0.2372      0.068     -3.485      0.001      -0.371      -0.104
x18           -0.0308      0.071     -0.434      0.664      -0.170       0.108
x19           -0.0130      0.059     -0.221      0.825      -0.128       0.102
x20           -0.1192      0.083     -1.442      0.149      -0.281       0.043
x21           -0.0403      0.050     -0.805      0.421      -0.138       0.058
x22           -0.0478      0.051     -0.941      0.347      -0.147       0.052
x23           -0.0599      0.046     -1.299      0.194      -0.150       0.030
x24            0.1338      0.113      1.179      0.238      -0.089       0.356
x25           -0.0592      0.068     -0.867      0.386      -0.193       0.075
x26           -0.0608      0.047     -1.299      0.194      -0.152       0.031
x27           -0.0230      0.063     -0.364      0.716      -0.147       0.101
x28           -0.0364      0.047     -0.771      0.441      -0.129       0.056
x29           -0.0860      0.056     -1.530      0.126      -0.196       0.024
x30           -0.0645      0.049     -1.315      0.189      -0.161       0.032
x31            0.0749      0.082      0.916      0.360      -0.085       0.235
x32           -0.0686      0.051     -1.349      0.177      -0.168       0.031
x33            0.0380      0.052      0.724      0.469      -0.065       0.141
x34           -0.0384      0.073     -0.523      0.601      -0.182       0.105
x35           -0.0294      0.049     -0.599      0.549      -0.126       0.067
x36           -0.0679      0.044     -1.556      0.120      -0.154       0.018
x37           -0.0427      0.062     -0.690      0.490      -0.164       0.078
x38           -0.0359      0.063     -0.568      0.570      -0.160       0.088
x39           -0.0617      0.045     -1.376      0.169      -0.150       0.026
x40           -0.0756      0.053     -1.428      0.153      -0.179       0.028
x41           -0.0356      0.068     -0.520      0.603      -0.170       0.099
x42           -0.0644      0.050     -1.277      0.202      -0.163       0.034
x43           -0.0781      0.057     -1.362      0.173      -0.191       0.034
x44            0.0325      0.050      0.655      0.513      -0.065       0.130
x45           -0.0460      0.048     -0.952      0.341      -0.141       0.049
x46           -0.0604      0.033     -1.856      0.064      -0.124       0.003
x47           -0.0374      0.043     -0.861      0.389      -0.122       0.048
x48           -0.0141      0.148     -0.095      0.924      -0.304       0.276
x49            0.0203      0.008      2.514      0.012       0.004       0.036
x50           -0.0458      0.016     -2.846      0.004      -0.077      -0.014
==============================================================================
Omnibus:                      234.465   Durbin-Watson:                   1.994
Prob(Omnibus):                  0.000   Jarque-Bera (JB):              630.705
Skew:                          -0.536   Prob(JB):                    1.11e-137
Kurtosis:                       5.262   Cond. No.                     1.07e+16
==============================================================================

Notes:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.
[2] The smallest eigenvalue is 2.48e-22. This might indicate that there are
strong multicollinearity problems or that the design matrix is singular.


# function to compute adjusted R-squared
def adj_r2_score(predictors, targets, predictions):
    r2 = r2_score(targets, predictions)
    n = predictors.shape[0]
    k = predictors.shape[1]
    return 1 - ((1 - r2) * (n - 1) / (n - k - 1))


# function to compute MAPE
def mape_score(targets, predictions):
    return np.mean(np.abs(targets - predictions) / targets) * 100


# function to compute different metrics to check performance of a regression model
def model_performance_regression(model, predictors, target):
    """
    Function to compute different metrics to check regression model performance

    model: regressor
    predictors: independent variables
    target: dependent variable
    """

    # predicting using the independent variables
    pred = model.predict(predictors)

    r2 = r2_score(target, pred)  # to compute R-squared
    adjr2 = adj_r2_score(predictors, target, pred)  # to compute adjusted R-squared
    rmse = np.sqrt(mean_squared_error(target, pred))  # to compute RMSE
    mae = mean_absolute_error(target, pred)  # to compute MAE
    mape = mape_score(target, pred)  # to compute MAPE

    # creating a dataframe of metrics
    df_perf = pd.DataFrame(
        {
            "RMSE": rmse,
            "MAE": mae,
            "R-squared": r2,
            "Adj. R-squared": adjr2,
            "MAPE": mape,
        },
        index=[0],
    )

    return df_perf


# checking model performance on train set (seen 70% data)
olsmodel1 = LinearRegression()
olsmodel1.fit(x_train, y_train)
print("Training Performance\n")
olsmodel1_train_perf = model_performance_regression(olsmodel1, x_train, y_train)
olsmodel1_train_perf

Training Performance


# checking model performance on test set (seen 30% data)
olsmodel1 = LinearRegression()
olsmodel1.fit(x_train, y_train)
print("Test Performance\n")
olsmodel1_test_perf = model_performance_regression(olsmodel1, x_test, y_test)
olsmodel1_test_perf

Test Performance


# Test for multicolinearity using Variance Inflation Factor(VIF)
# Let's define a function to check VIF.

def checking_vif(predictors):
    # Check and clean the predictors DataFrame
    predictors = predictors.select_dtypes(include=[np.number])  # Select numeric columns only
    
    
    vif = pd.DataFrame()
    vif["feature"] = predictors.columns

    # Calculate VIF for each feature
    vif["VIF"] = [variance_inflation_factor(predictors.values, i) for i in range(len(predictors.columns))]

    return vif


# Call the checking_vif function on the train data to check VIF
train_vif = checking_vif(x_train)
print(train_vif)

                 feature        VIF
0                  const  95.880541
1            screen_size   6.462515
2         main_camera_mp   2.055485
3       selfie_camera_mp   2.565127
4             int_memory   1.224326
5                    ram   2.008373
6                battery   3.836712
7                 weight   5.554191
8              days_used   2.472959
9   normalized_new_price   2.570473
10            4g_encoded   2.310097
11            5g_encoded   1.695259
12         age_of_device   4.505587


# specify the column to drop
col_to_drop = "screen_size"  ## Column to be dropped

# specify the train data from which to drop the column specified
x_train2 = x_train.loc[:, ~x_train.columns.str.startswith(col_to_drop)]
x_test2 = x_test.loc[:, ~x_test.columns.str.startswith(col_to_drop)]

# Check VIF now
vif = checking_vif(x_train2)
print("VIF after dropping", col_to_drop)
vif

VIF after dropping screen_size


# checking model performance on train set (seen 70% data)
olsmodel1 = LinearRegression()
olsmodel1.fit(x_train, y_train)
print("Training Performance\n")
olsmodel1_train_perf = model_performance_regression(olsmodel1, x_train, y_train)
olsmodel1_train_perf

Training Performance


# checking model performance on test set (seen 30% data)
olsmodel1 = LinearRegression()
olsmodel1.fit(x_train, y_train)
print("Test Performance\n")
olsmodel1_test_perf = model_performance_regression(olsmodel1, x_test, y_test)
olsmodel1_test_perf

Test Performance


# specify the column to drop
col_to_drop = "weight"  ## Column to be dropped

# specify the train data from which to drop the column specified
x_train2 = x_train.loc[:, ~x_train.columns.str.startswith(col_to_drop)]
x_test2 = x_test.loc[:, ~x_test.columns.str.startswith(col_to_drop)]

# Check VIF now
vif = checking_vif(x_train2)
print("VIF after dropping", col_to_drop)
vif

VIF after dropping weight


# checking model performance on train set (seen 70% data)
olsmodel1 = LinearRegression()
olsmodel1.fit(x_train, y_train)
print("Training Performance\n")
olsmodel1_train_perf = model_performance_regression(olsmodel1, x_train, y_train)
olsmodel1_train_perf

Training Performance


# checking model performance on test set (seen 30% data)
olsmodel1 = LinearRegression()
olsmodel1.fit(x_train, y_train)
print("Test Performance\n")
olsmodel1_test_perf = model_performance_regression(olsmodel1, x_test, y_test)
olsmodel1_test_perf

Test Performance


# Convert the 'y_train' Pandas Series to a NumPy array with appropriate data type
x_train_array = x_train.values.astype(float)
y_train_array = y_train.values.astype(float)

# Initial list of columns
cols = x_train.columns.tolist()

# Setting an initial max p-value
max_p_value = 1

while len(cols) > 0:
    # Defining the train set
    x_train_aux = x_train_array[:, [x_train.columns.get_loc(col) for col in cols]]

    # Fitting the model
    model = sm.OLS(y_train_array, sm.add_constant(x_train_aux)).fit()

    # Getting the p-values and the maximum p-value
    p_values = model.pvalues

    # Find the index of the variable with the maximum p-value
    max_p_value_index = np.argmax(p_values)

    max_p_value = p_values[max_p_value_index]

    if max_p_value > 0.05:
        feature_with_p_max = cols[max_p_value_index]
        cols.remove(feature_with_p_max)
    else:
        break

selected_features = cols

print(selected_features)

['const', 'screen_size', 'main_camera_mp', 'selfie_camera_mp', 'int_memory', 'ram', 'battery', 'weight', 'normalized_new_price', '4g_encoded', '5g_encoded', 'age_of_device', 'brand_name_Celkon', 'brand_name_Nokia', 'brand_name_Xiaomi', 'os_Others', '4g_yes', '5g_yes']


# Specify the train and test data with selected features
x_train3 = x_train[selected_features]
x_test3 = x_test[selected_features]


# Convert Pandas Series 'y_train' to a NumPy array with a suitable data type
y_train_array = y_train.values.astype(float)

# Define x_train3 with selected features from x_train
x_train3 = x_train[selected_features]

# Convert x_train3 Pandas DataFrame to a NumPy array with a suitable data type
x_train3_array = x_train3.values.astype(float)

# Fit OLS model on the updated dataset
olsmodel2 = sm.OLS(y_train_array, sm.add_constant(x_train3_array)).fit()

# Print the summary of the OLS model
print(olsmodel2.summary())

                            OLS Regression Results                            
==============================================================================
Dep. Variable:                      y   R-squared:                       0.847
Model:                            OLS   Adj. R-squared:                  0.846
Method:                 Least Squares   F-statistic:                     886.8
Date:                Fri, 22 Mar 2024   Prob (F-statistic):               0.00
Time:                        15:34:48   Log-Likelihood:                 110.96
No. Observations:                2417   AIC:                            -189.9
Df Residuals:                    2401   BIC:                            -97.27
Df Model:                          15                                         
Covariance Type:            nonrobust                                         
==============================================================================
                 coef    std err          t      P>|t|      [0.025      0.975]
------------------------------------------------------------------------------
const          1.3715      0.052     26.565      0.000       1.270       1.473
x1             0.0291      0.003      8.473      0.000       0.022       0.036
x2             0.0234      0.001     16.151      0.000       0.021       0.026
x3             0.0119      0.001     10.644      0.000       0.010       0.014
x4             0.0002   6.66e-05      2.836      0.005    5.83e-05       0.000
x5             0.0293      0.005      5.686      0.000       0.019       0.039
x6          -1.46e-05   7.19e-06     -2.030      0.043   -2.87e-05   -4.94e-07
x7             0.0008      0.000      6.200      0.000       0.001       0.001
x8             0.4092      0.011     36.760      0.000       0.387       0.431
x9             0.0230      0.008      3.023      0.003       0.008       0.038
x10           -0.0450      0.016     -2.862      0.004      -0.076      -0.014
x11           -0.0218      0.004     -5.847      0.000      -0.029      -0.014
x12           -0.1905      0.053     -3.571      0.000      -0.295      -0.086
x13            0.0823      0.030      2.771      0.006       0.024       0.140
x14            0.0829      0.025      3.296      0.001       0.034       0.132
x15           -0.0598      0.030     -1.993      0.046      -0.119      -0.001
x16            0.0230      0.008      3.023      0.003       0.008       0.038
x17           -0.0450      0.016     -2.862      0.004      -0.076      -0.014
==============================================================================
Omnibus:                      240.704   Durbin-Watson:                   1.993
Prob(Omnibus):                  0.000   Jarque-Bera (JB):              674.212
Skew:                          -0.537   Prob(JB):                    3.95e-147
Kurtosis:                       5.354   Cond. No.                     5.23e+19
==============================================================================

Notes:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.
[2] The smallest eigenvalue is 1.02e-29. This might indicate that there are
strong multicollinearity problems or that the design matrix is singular.


# Create a DataFrame to store actual, fitted, and residual values
df_pred = pd.DataFrame()

# Add actual, fitted, and residual values to the DataFrame
df_pred["Actual Values"] = y_train  # actual values
df_pred["Fitted Values"] = olsmodel2.fittedvalues  # predicted values
df_pred["Residuals"] = olsmodel2.resid  # residuals

# Display the first few rows of the DataFrame
df_pred.head()


# let's plot the fitted values vs residuals

sns.residplot(
    data=df_pred, x="Fitted Values", y="Residuals", color="purple", lowess=True
)
plt.xlabel("Fitted Values")
plt.ylabel("Residuals")
plt.title("Fitted vs Residual plot")
plt.show()


# Plot the distribution of residuals as a histogram using Seaborn
sns.histplot(
    data=df_pred, x="Residuals", kde=True
)  # specify 'x' as 'Residuals' for the histogram

plt.title("Normality of residuals")
plt.show()


import pylab
import scipy.stats as stats

# Create a Q-Q plot to check the normality of residuals
stats.probplot(df_pred["Residuals"], dist="norm", plot=pylab)

plt.show()


# Perform Shapiro-Wilk test of normality on the Residuals
stats.shapiro(df_pred["Residuals"])

ShapiroResult(statistic=0.963483452796936, pvalue=2.9948930717316565e-24)


import statsmodels.stats.api as sms
from statsmodels.compat import lzip

name = ["F statistic", "p-value"]

# Define the selected features based on column names present in df_pred
selected_features = [
    "Actual Values",
    "Fitted Values",
]  # Update this with appropriate columns from df_pred

# Apply the Goldfeld-Quandt test for heteroscedasticity
test = sms.het_goldfeldquandt(df_pred["Residuals"], df_pred[selected_features])

lzip(name, test)

[('F statistic', 0.48604057532391814), ('p-value', 0.9999999999999999)]


pred = olsmodel2.predict(x_test3)
df_pred_test = pd.DataFrame({"Actual": y_test, "Predicted": pred})
df_pred_test.sample(10, random_state=1)


# Define x_train_final needs to be defined based on x_train3
x_train_final = x_train3.copy()

# Convert Pandas Series 'y_train' and feature columns to float type
y_train_float = y_train.astype(float)
x_train_final_float = x_train_final.astype(float)

# Fit the OLS model on the updated dataset with float type data
olsmodel_final = sm.OLS(y_train_float, sm.add_constant(x_train_final_float)).fit()

# Print the summary of the OLS model
print(olsmodel_final.summary())

                              OLS Regression Results                             
=================================================================================
Dep. Variable:     normalized_used_price   R-squared:                       0.847
Model:                               OLS   Adj. R-squared:                  0.846
Method:                    Least Squares   F-statistic:                     886.8
Date:                   Fri, 22 Mar 2024   Prob (F-statistic):               0.00
Time:                           16:58:43   Log-Likelihood:                 110.96
No. Observations:                   2417   AIC:                            -189.9
Df Residuals:                       2401   BIC:                            -97.27
Df Model:                             15                                         
Covariance Type:               nonrobust                                         
========================================================================================
                           coef    std err          t      P>|t|      [0.025      0.975]
----------------------------------------------------------------------------------------
const                    1.3715      0.052     26.565      0.000       1.270       1.473
screen_size              0.0291      0.003      8.473      0.000       0.022       0.036
main_camera_mp           0.0234      0.001     16.151      0.000       0.021       0.026
selfie_camera_mp         0.0119      0.001     10.644      0.000       0.010       0.014
int_memory               0.0002   6.66e-05      2.836      0.005    5.83e-05       0.000
ram                      0.0293      0.005      5.686      0.000       0.019       0.039
battery               -1.46e-05   7.19e-06     -2.030      0.043   -2.87e-05   -4.94e-07
weight                   0.0008      0.000      6.200      0.000       0.001       0.001
normalized_new_price     0.4092      0.011     36.760      0.000       0.387       0.431
4g_encoded               0.0230      0.008      3.023      0.003       0.008       0.038
5g_encoded              -0.0450      0.016     -2.862      0.004      -0.076      -0.014
age_of_device           -0.0218      0.004     -5.847      0.000      -0.029      -0.014
brand_name_Celkon       -0.1905      0.053     -3.571      0.000      -0.295      -0.086
brand_name_Nokia         0.0823      0.030      2.771      0.006       0.024       0.140
brand_name_Xiaomi        0.0829      0.025      3.296      0.001       0.034       0.132
os_Others               -0.0598      0.030     -1.993      0.046      -0.119      -0.001
4g_yes                   0.0230      0.008      3.023      0.003       0.008       0.038
5g_yes                  -0.0450      0.016     -2.862      0.004      -0.076      -0.014
==============================================================================
Omnibus:                      240.704   Durbin-Watson:                   1.993
Prob(Omnibus):                  0.000   Jarque-Bera (JB):              674.212
Skew:                          -0.537   Prob(JB):                    3.95e-147
Kurtosis:                       5.354   Cond. No.                     5.23e+19
==============================================================================

Notes:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.
[2] The smallest eigenvalue is 1.02e-29. This might indicate that there are
strong multicollinearity problems or that the design matrix is singular.


# Check model performance on train set ( 70& of the data seen)
print(" Training Performance")
olsmodel_final_train_perf = model_performance_regression(
    olsmodel_final, x_train_final, y_train
)
olsmodel_final_train_perf

 Training Performance


# checking model performance on test set (30% of the data seen)
print("Test Performance\n")
olsmodel_final_test_perf = model_performance_regression(
    olsmodel_final, x_test_final, y_test
)
olsmodel_final_test_perf

Test Performance

	count	unique	top	freq	mean	std	min	25%	50%	75%	max
brand_name	3454	34	Others	502	NaN	NaN	NaN	NaN	NaN	NaN	NaN
os	3454	4	Android	3214	NaN	NaN	NaN	NaN	NaN	NaN	NaN
screen_size	3454.0	NaN	NaN	NaN	13.713115	3.80528	5.08	12.7	12.83	15.34	30.71
4g	3454	2	yes	2335	NaN	NaN	NaN	NaN	NaN	NaN	NaN
5g	3454	2	no	3302	NaN	NaN	NaN	NaN	NaN	NaN	NaN
main_camera_mp	3275.0	NaN	NaN	NaN	9.460208	4.815461	0.08	5.0	8.0	13.0	48.0
selfie_camera_mp	3452.0	NaN	NaN	NaN	6.554229	6.970372	0.0	2.0	5.0	8.0	32.0
int_memory	3450.0	NaN	NaN	NaN	54.573099	84.972371	0.01	16.0	32.0	64.0	1024.0
ram	3450.0	NaN	NaN	NaN	4.036122	1.365105	0.02	4.0	4.0	4.0	12.0
battery	3448.0	NaN	NaN	NaN	3133.402697	1299.682844	500.0	2100.0	3000.0	4000.0	9720.0
weight	3447.0	NaN	NaN	NaN	182.751871	88.413228	69.0	142.0	160.0	185.0	855.0
release_year	3454.0	NaN	NaN	NaN	2015.965258	2.298455	2013.0	2014.0	2015.5	2018.0	2020.0
days_used	3454.0	NaN	NaN	NaN	674.869716	248.580166	91.0	533.5	690.5	868.75	1094.0
normalized_used_price	3454.0	NaN	NaN	NaN	4.364712	0.588914	1.536867	4.033931	4.405133	4.7557	6.619433
normalized_new_price	3454.0	NaN	NaN	NaN	5.233107	0.683637	2.901422	4.790342	5.245892	5.673718	7.847841

	count	unique	top	freq	mean	std	min	25%	50%	75%	max
brand_name	3454	34	Others	502	NaN	NaN	NaN	NaN	NaN	NaN	NaN
os	3454	4	Android	3214	NaN	NaN	NaN	NaN	NaN	NaN	NaN
screen_size	3454.0	NaN	NaN	NaN	13.713115	3.80528	5.08	12.7	12.83	15.34	30.71
4g	3454	2	yes	2335	NaN	NaN	NaN	NaN	NaN	NaN	NaN
5g	3454	2	no	3302	NaN	NaN	NaN	NaN	NaN	NaN	NaN
main_camera_mp	3454.0	NaN	NaN	NaN	9.617597	4.749438	0.08	5.0	8.0	13.0	48.0
selfie_camera_mp	3454.0	NaN	NaN	NaN	6.555067	6.96844	0.0	2.0	5.0	8.0	32.0
int_memory	3454.0	NaN	NaN	NaN	54.528474	84.934991	0.01	16.0	32.0	64.0	1024.0
ram	3454.0	NaN	NaN	NaN	4.03262	1.368598	0.02	4.0	4.0	4.0	12.0
battery	3454.0	NaN	NaN	NaN	3132.577446	1298.884193	500.0	2100.0	3000.0	4000.0	9720.0
weight	3454.0	NaN	NaN	NaN	182.636856	88.360445	69.0	142.0	160.0	185.0	855.0
days_used	3454.0	NaN	NaN	NaN	674.869716	248.580166	91.0	533.5	690.5	868.75	1094.0
normalized_used_price	3454.0	NaN	NaN	NaN	4.364712	0.588914	1.536867	4.033931	4.405133	4.7557	6.619433
normalized_new_price	3454.0	NaN	NaN	NaN	5.233107	0.683637	2.901422	4.790342	5.245892	5.673718	7.847841
4g_encoded	3454.0	NaN	NaN	NaN	0.676028	0.468057	0.0	0.0	1.0	1.0	1.0
5g_encoded	3454.0	NaN	NaN	NaN	0.044007	0.20514	0.0	0.0	0.0	0.0	1.0
age_of_device	3454.0	NaN	NaN	NaN	5.034742	2.298455	1.0	3.0	5.5	7.0	8.0

	Actual Values	Fitted Values	Residuals
1744	4.261975	4.311553	-0.049578
3141	4.175156	3.860832	0.314324
1233	4.117410	4.433246	-0.315836
3046	3.782597	3.848331	-0.065733
2649	3.981922	3.920911	0.061011

	Actual	Predicted
1174	4.553772	4.494382
2247	4.330996	4.10073
2991	4.180828	4.068603
2997	4.291007	4.238787
2982	4.649761	4.510048
479	4.284689	4.227465
17	4.777020	4.715704
471	4.721886	4.487669
2918	4.482550	4.501051
602	3.852485	4.161353

	brand_name	os	screen_size	4g	5g	main_camera_mp	selfie_camera_mp	int_memory	ram	battery	weight	release_year	days_used	normalized_used_price	normalized_new_price
0	Honor	Android	14.50	yes	no	13.0	5.0	64.0	3.0	3020.0	146.0	2020	127	4.307572	4.715100
1	Honor	Android	17.30	yes	yes	13.0	16.0	128.0	8.0	4300.0	213.0	2020	325	5.162097	5.519018
2	Honor	Android	16.69	yes	yes	13.0	8.0	128.0	8.0	4200.0	213.0	2020	162	5.111084	5.884631
3	Honor	Android	25.50	yes	yes	13.0	8.0	64.0	6.0	7250.0	480.0	2020	345	5.135387	5.630961
4	Honor	Android	15.32	yes	no	13.0	8.0	64.0	3.0	5000.0	185.0	2020	293	4.389995	4.947837

	feature	VIF
0	const	88.136335
1	main_camera_mp	2.044983
2	selfie_camera_mp	2.562639
3	int_memory	1.220129
4	ram	1.970646
5	battery	3.555564
6	weight	2.737859
7	days_used	2.467377
8	normalized_new_price	2.512565
9	4g_encoded	2.309453
10	5g_encoded	1.678568
11	age_of_device	4.389092

	feature	VIF
0	const	87.709984
1	screen_size	3.185604
2	main_camera_mp	1.934964
3	selfie_camera_mp	2.531386
4	int_memory	1.224326
5	ram	1.970930
6	battery	3.473183
7	days_used	2.461660
8	normalized_new_price	2.567212
9	4g_encoded	2.282841
10	5g_encoded	1.687623
11	age_of_device	4.402847